package xyz.ssf.cloud.project.system.controller;

import lombok.RequiredArgsConstructor;
import org.springframework.beans.BeanUtils;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.*;
import xyz.ssf.cloud.common.core.domain.R;
import xyz.ssf.cloud.common.core.domain.PageResult;
import xyz.ssf.cloud.project.system.domain.SysRole;
import xyz.ssf.cloud.project.system.domain.dto.RoleDTO;
import xyz.ssf.cloud.project.system.domain.dto.RoleQuery;
import xyz.ssf.cloud.project.system.domain.vo.RoleVO;
import xyz.ssf.cloud.project.system.domain.vo.UserRoleVO;
import xyz.ssf.cloud.project.system.service.SysRoleService;

import java.util.List;

/**
 * 角色信息
 */
@RestController
@RequestMapping("/koi/sysRole")
@RequiredArgsConstructor
public class SysRoleController {
    
    private final SysRoleService roleService;
    
    /**
     * 分页查询角色列表
     */
    @GetMapping("/listPage")
    public R<PageResult<RoleVO>> listPage(RoleQuery query) {
        PageResult<RoleVO> page = roleService.selectRoleList(query);
        return R.success(page);
    }
    
    /**
     * 查询所有正常角色
     */
    @GetMapping("/listNormalRole/{userId}")
    public R<UserRoleVO> listNormalRole(@PathVariable("userId") Long userId) {
        UserRoleVO userRoleVO = roleService.getUserRoleList(userId);
        return R.success(userRoleVO);
    }
    
    /**
     * 根据角色ID查询角色信息
     */
    @GetMapping("/getById/{id}")
    public R<SysRole> getById(@PathVariable("id") Long id) {
        SysRole role = roleService.selectRoleById(id);
        return R.success(role);
    }
    
    /**
     * 新增角色
     */
    @PostMapping("/add")
    public R<Void> add(@Validated @RequestBody RoleDTO roleDTO) {
        // 校验角色名称是否唯一
        SysRole checkRole = new SysRole();
        checkRole.setRoleName(roleDTO.getRoleName());
        if (!roleService.checkRoleNameUnique(checkRole)) {
            return R.error("新增角色'" + roleDTO.getRoleName() + "'失败，角色名称已存在");
        }
        
        // 校验角色编号是否唯一
        checkRole = new SysRole();
        checkRole.setRoleCode(roleDTO.getRoleCode());
        if (!roleService.checkRoleCodeUnique(checkRole)) {
            return R.error("新增角色'" + roleDTO.getRoleName() + "'失败，角色编号已存在");
        }
        
        // 将DTO转换为实体对象
        SysRole role = new SysRole();
        BeanUtils.copyProperties(roleDTO, role);
        
        int rows = roleService.insertRole(role);
        return rows > 0 ? R.success() : R.error("新增角色失败");
    }
    
    /**
     * 修改角色
     */
    @PostMapping("/update")
    public R<Void> update(@Validated @RequestBody RoleDTO roleDTO) {
        // 校验角色是否存在
        SysRole existRole = roleService.selectRoleById(roleDTO.getId());
        if (existRole == null) {
            return R.error("修改角色失败，角色不存在");
        }
        
        // 校验角色名称是否唯一
        SysRole checkRole = new SysRole();
        checkRole.setId(roleDTO.getId());
        checkRole.setRoleName(roleDTO.getRoleName());
        if (!roleService.checkRoleNameUnique(checkRole)) {
            return R.error("修改角色'" + roleDTO.getRoleName() + "'失败，角色名称已存在");
        }
        
        // 校验角色编号是否唯一
        checkRole = new SysRole();
        checkRole.setId(roleDTO.getId());
        checkRole.setRoleCode(roleDTO.getRoleCode());
        if (!roleService.checkRoleCodeUnique(checkRole)) {
            return R.error("修改角色'" + roleDTO.getRoleName() + "'失败，角色编号已存在");
        }
        
        // 将DTO转换为实体对象
        SysRole role = new SysRole();
        BeanUtils.copyProperties(roleDTO, role);
        
        int rows = roleService.updateRole(role);
        return rows > 0 ? R.success() : R.error("修改角色失败");
    }
    
    /**
     * 修改角色状态
     */
    @PostMapping("/updateStatus/{id}/{status}")
    public R<Void> updateStatus(@PathVariable("id") Long id, @PathVariable("status") String status) {
        // 验证id参数
        if (id == null) {
            return R.error("角色ID不能为空");
        }
        
        SysRole role = new SysRole();
        role.setId(id);
        role.setRoleStatus(status);
        int rows = roleService.updateRoleStatus(role);
        return rows > 0 ? R.success() : R.error("修改角色状态失败");
    }
    
    /**
     * 删除角色
     */
    @PostMapping("/deleteById/{id}")
    public R<Void> deleteById(@PathVariable("id") Long id) {
        try {
            int rows = roleService.deleteRoleById(id);
            return rows > 0 ? R.success() : R.error("删除角色失败");
        } catch (Exception e) {
            return R.error(e.getMessage());
        }
    }
    
    /**
     * 批量删除角色
     */
    @PostMapping("/batchDelete")
    public R<Void> batchDelete(@RequestBody List<Long> ids) {
        try {
            int rows = roleService.deleteRoleByIds(ids.toArray(new Long[0]));
            return rows > 0 ? R.success() : R.error("批量删除角色失败");
        } catch (Exception e) {
            return R.error(e.getMessage());
        }
    }
    
    /**
     * 查询角色关联的菜单ID集合
     */
    @GetMapping("/getRoleMenuList/{id}")
    public R<List<Long>> getRoleMenuList(@PathVariable("id") Long id) {
        List<Long> menuIds = roleService.getRoleMenuList(id);
        return R.success(menuIds);
    }
    
    /**
     * 保存角色和菜单关联关系
     */
    @PostMapping("/saveRoleMenu/{id}")
    public R<Void> saveRoleMenu(@PathVariable("id") Long id, @RequestBody List<Long> menuIds) {
        int rows = roleService.saveRoleMenu(id, menuIds);
        return rows > 0 ? R.success() : R.error("保存角色菜单关联关系失败");
    }
    
    /**
     * 为当前登录用户分配角色
     */
    @PostMapping("/assignUserRole")
    public R<Void> assignUserRole(@RequestBody List<Long> roleIds) {
        int rows = roleService.assignUserRole(roleIds);
        return rows > 0 ? R.success() : R.error("分配角色失败");
    }
} 